Repository navigation
Conversation
…ce and WorkflowManagerInterface - Introduced ScriptModuleInterface for module exposure in PHP scripts. - Updated ServiceTaskImplementationInterface to allow an optional timeout parameter in the run method. - Modified WorkflowManagerInterface to include a timeout parameter in the runServiceImplementation method.
…-process - Introduced ScriptRuntime facade for managing script execution context and module registration. - Added InProcessPhpRunner to run PHP scripts directly within the Laravel process. - Updated ScriptRunner to support in-process execution based on script properties. - Enhanced WorkflowManager and Script models to accommodate new functionality, including allow_in_process property. - Implemented bootstrap for in-process execution and improved error handling for script execution.
- Introduced ScriptExecutionContext to encapsulate per-run context for script modules. - The class includes properties for data, configuration, user, token ID, timeout, script ID, and source. - This addition supports the in-process execution of PHP scripts by providing necessary context information.
- Introduced CoreServiceTask class to handle the execution of allowlisted PHP scripts without Docker or the script microservice. - Implemented validation for script configuration, including script ID and user requirements. - Added support for both module-based and bare execution modes. - Enhanced error handling for various execution scenarios, ensuring robust configuration checks. - Utilized ScriptRuntime and InProcessPhpRunner for executing scripts based on the defined context.
- Enhanced ScriptController to support a new `run_in_process` property for script previews, allowing execution via an in-process PHP runner when enabled. - Updated TestScript job to handle the new `runInProcess` parameter, enabling direct script execution without Docker. - Introduced `shouldPreviewInProcess` method to determine if in-process execution is applicable based on script properties and request flags. - Added comprehensive unit tests to validate in-process execution scenarios and ensure proper handling of configuration and execution context. - Implemented new test cases for CoreServiceTask to verify in-process script execution and error handling for various conditions.
commit b84543b Author: AugustoLopezProcess <augusto.lopez+github@processmaker.com> Date: Tue Apr 21 08:27:15 2026 -0400 Adding plugin admin ui commit ca8a863 Author: Nolan Ehrstrom <github@nolanpro.com> Date: Mon Mar 9 11:01:46 2026 -0700 Add controllers and routes for plugin UI Copied from feature/plugins-poc-vite-ui (just without the vite/Vue3 integration) commit 3cc89bc Merge: 9e9b4aa 5da27ce Author: Nolan Ehrstrom <github@nolanpro.com> Date: Mon Mar 9 10:58:27 2026 -0700 Merge branch 'task/FOUR-28803' into feature/plugins-poc commit 9e9b4aa Author: Nolan Ehrstrom <github@nolanpro.com> Date: Mon Jan 19 12:30:54 2026 -0800 Add install command and cached routes commit 4a5df14 Author: Nolan Ehrstrom <github@nolanpro.com> Date: Wed Dec 10 09:29:20 2025 -0800 Start on plugins
Updating feature/plugins-poc-4 with last changes in develop
FOUR-32722 Some adjustments in plugins installation
…the command: php artisan horizon:terminate
FOUR-32760 After install/enable/disable a plugin, should be executed the command: php artisan horizon:terminate
…ink, add load screen-builder-form.js files from plugin
…ink, add load screen-builder-form.js files from plugin
…ink, add load screen-builder-form.js files from plugin
…ink, add load screen-builder-form.js files from plugin
| */ | ||
| private function buildEnvironment(?User $user, ?GenerateAccessToken $accessToken): array | ||
| { | ||
| $env = array_merge($_ENV, $_SERVER); |
There was a problem hiding this comment.
🔒 Agentic Security Review
Severity: HIGH
Description: Bare in-process PHP execution forwards the queue worker's environment, including application secrets, into the script subprocess. buildEnvironment() starts from array_merge($_ENV, $_SERVER) and Process::env() passes that array to Symfony Process. Symfony Process 8.1 then overlays the parent environment (getDefaultEnv()) and does not drop keys that were merely omitted, so APP_KEY, DB_PASSWORD, and the rest of the worker environment remain readable with getenv() inside script.php. The script return value is JSON-encoded to stdout and returned to the caller.
Impact: A script author is a lower-trust actor than the worker. Docker execution only injects EnvironmentVariable rows, HOST_URL, smart-extract settings, and a run-as API token. Bare mode is the supported subprocess path (CORE_SERVICE_TASK_EXECUTION other than modules) whose purpose is a PHP process without Laravel, but it still exposes the worker credential set. The script can return those values in preview output or process data, or send them off-box. APP_KEY and database credentials are full application credentials, not script-scoped configuration. This path is off by default: core-service-task is disabled and execution defaults to modules, which does not call InProcessPhpRunner. It is reachable once an operator sets CORE_SERVICE_TASK_ENABLED=true and CORE_SERVICE_TASK_EXECUTION=bare. In that configuration an authenticated user with view-scripts can POST scripts/{script}/preview with run_in_process=true and arbitrary PHP (allow_in_process is not required). The same runner is also used for allow_in_process PHP script tasks and core service tasks.
Remediation: Build the subprocess environment from the same allowlist as Base::getEnvironmentVariables (EnvironmentVariable rows, HOST_URL/APP_URL, smart-extract settings, and the run-as API token). Do not merge $_ENV or $_SERVER into that array. Because Symfony Process 8 still merges getDefaultEnv(), set every inherited name that is not on the allowlist to false before proc_open so those variables are dropped. Add a test that getenv('APP_KEY') and getenv('DB_PASSWORD') are empty in the child while API_TOKEN and an EnvironmentVariable row are present.
| } | ||
|
|
||
| File::ensureDirectoryExists(dirname($destination)); | ||
| File::copyDirectory($source, $destination); |
There was a problem hiding this comment.
🔒 Agentic Security Review
Severity: MEDIUM
Description: Tenant plugin asset publish dereferences symlinks under the plugin public/ tree and writes the target bytes into the tenant document root as a normal file. git clone (no core.symlinks=false) leaves those links in storage/tenant_{id}/plugins/{repo}/public. publishPlugin() accepts the tree when is_dir() is true, which follows a symlink, and copyPublicDirectory() calls File::copyDirectory() with no is_link skip and no realpath containment. Laravel's copier uses is_dir()/SplFileInfo::isDir() and PHP copy(), both of which follow links, so a file symlink is materialized and a directory symlink is recursed into. A plugin repository can therefore point public/leak at a stable relative path such as ../../../../../.env (from storage/tenant_{id}/plugins/{repo}/public up to the app root) and the file contents are written under public/storage/tenant_{id}/vendor/processmaker/packages/{package}/, which is the static URL prefix /storage/tenant_{id}/vendor/processmaker/packages/{package}/. That publish runs from finishPluginSetup after clone, including when composer.json has no scripts and no extra.laravel.providers, so the copy itself is enough to place the bytes on disk.
Impact: A plugin repository author is a lower-trust actor than the host filesystem. An operator with manage-plugins who installs that https git URL (multitenancy on, tenant_plugin_assets_enabled default true, queue job tenant-aware) causes host files readable by the PHP user, including the application .env and other credential files, to be stored inside the web root. The resulting object is an ordinary file on the tenant public disk (public/storage/tenant_{id} is the tenants:storage-link path into storage/app/public, and a missing link still creates a directory under public/), so it is fetched as a static asset with no application auth. That crosses the plugin public-directory boundary the new publisher is responsible for. Zip extraction was not verified to recreate symlink entries; the confirmed path is git clone into the plugin directory followed by this publish.
Remediation: While publishing plugin public assets, skip symlink entries (is_link) and do not recurse through directory symlinks. Before each write, require realpath of the source file to remain under realpath of the plugin public directory, and require the destination to remain under the tenant package directory. Apply the same containment in PluginManager::copyDirectory so a local or extracted tree cannot materialize out-of-tree targets before publish.
FOUR-34384 Migrate ProcessMaker Core skills to Skills repository
…izacion of BPMN - FE
feat(FOUR-34380):Subprocess Inline to group task to reduce the visualizacion of BPMN - FE
| # Schema/heuristic gates use requirements-schema.txt (pinned PyYAML). | ||
| PyYAML==6.0.3 | ||
| laya>=0.3.21,<0.4 | ||
| laya-evals>=0.1.0 |
There was a problem hiding this comment.
🔒 Agentic Security Review
Severity: MEDIUM
Description: The new Laya extras manifest depends on PyPI project laya-evals>=0.1.0. That project is owned by PyPI user gjxv (github.com/Gjusev/laya-evals), not Convai Innovations, and its own description says it is not the laya-evals CLI shipped with upstream laya. The quality harness only imports laya.Router. README.md and run_laya_eval.sh still tell an operator to pip install -r requirements.txt, so that install trusts every later gjxv release. Published laya-evals 0.1.0 has no console script, so this release does not itself overwrite upstream laya's laya-evals entry point; the open range lets a later release add that script or run code from its build backend.
Impact: An operator or agent who follows the new optional Laya install instructions installs and can execute code from an unrelated publisher in the same environment as laya. That is a new provenance trust of a third-party PyPI project, with an unbounded upper version, on a name that collides with upstream laya's documented eval CLI. Repo CI does not install this file today; the blast radius is every environment that opts into the documented requirements file, including a later in-range release chosen by that publisher.
Remediation: Remove laya-evals from requirements.txt. The harness only needs the pinned laya distribution, which already documents its own laya-evals CLI. If a separate extra is intentional, depend on a hash-pinned artifact from the same publisher as laya, not the colliding PyPI name on an open range.
… mode to scripts. Introduced `hasExplicitReturn` method to determine return statements in scripts. Updated core service task configuration to set default execution mode to 'bare' and added migration for `execution_mode` column in scripts and script_versions tables. Expanded PermissionSeeder to include 'run-in-process-modules' permission. Added unit tests for legacy result variable and explicit scalar return handling in ScriptRuntime.
…cks. Implemented `authorizeModulesExecution` method in `ScriptController` to manage execution modes. Updated `Script` model to include `execution_mode` property and validation rules. Introduced `ScriptExecutionModeResolver` service for determining execution modes. Enhanced UI to allow selection of execution mode in script editing. Added tests for execution mode functionality and authorization checks.
…roduced `canUseModules` method for streamlined permission validation in `ScriptController`, `ScriptExporter`, and `TestScript`. Updated tests to ensure non-privileged users fall back to bare execution mode when duplicating or editing scripts. Enhanced `ScriptRuntime` to handle nested return statements correctly.
…mportController and ImportV2. Refactor ScriptExporter to utilize the importing user ID for permission checks. Update execution mode handling in ScriptController to default to bare mode. Add tests for import behavior based on user authorization and execution mode preservation. Improve ScriptRuntime to handle nested curly braces correctly.
…Extracted logic for handling tokens and brace management into dedicated methods. Updated unit tests to reflect changes in helper function syntax.
…esses Port deploy/pull endpoints and BPMN portable reference resolution from package-skeleton. Register canonical /deploy-* routes and package-skeleton BC aliases; add feature tests for upsert flows. https://processmaker.atlassian.net/browse/FOUR-34395
…property to facilitate permission checks in API tests, ensuring proper authorization during script execution tests.
feat(FOUR-34395): add core deploy sync for scripts, screens, and proc…
| Route::post('package-skeleton/deploy-process', [DeployProcess::class, 'deployProcess']) | ||
| ->name('package-skeleton.deploy-process'); | ||
| Route::get('package-skeleton/process-bpmn', [DeployProcess::class, 'getProcessBpmn']) | ||
| ->name('package-skeleton.process-bpmn'); |
There was a problem hiding this comment.
Deploy routes skip permission checks
High Severity
The new deploy and pull endpoints sit on auth:api only, with no can:create-* / can:edit-* / can:view-* checks that the matching process, screen, and script CRUD routes use. Any authenticated API user can create or overwrite assets by name and read full BPMN, YAML, and PHP. Updating an existing script keeps its run_as_user_id, so replaced code later runs as that privileged user.
Additional Locations (2)
Reviewed by Cursor Bugbot for commit 4b27368. Configure here.
| } | ||
|
|
||
| $script->code = $code; | ||
| $script->save(); |
There was a problem hiding this comment.
Script deploy ignores existing language
Medium Severity
deployScript looks up scripts only by title and, on update, writes PHP into code without changing language or script_executor_id. A JavaScript or Python script with the same title keeps its non-PHP runner, so the new body is stored as PHP but executed with the wrong executor.
Reviewed by Cursor Bugbot for commit 4b27368. Configure here.
| return $php; | ||
| } | ||
|
|
||
| return ScriptExecutor::query()->orderBy('id')->first(); |
There was a problem hiding this comment.
Non-PHP executor used for scripts
Medium Severity
After php-nayra and php, resolveForNewScript returns the lowest-id executor of any language. deployScript then stores PHP source with that executor’s language, so a new script can be created as javascript, python, or similar while its body is PHP.
Additional Locations (1)
Reviewed by Cursor Bugbot for commit 4b27368. Configure here.
| return $match[1] . $match[2] . '${process:' . $name . '}' . $match[2]; | ||
| }, | ||
| $bpmn | ||
| ); |
There was a problem hiding this comment.
Process restore matches unrelated IDs
Medium Severity
restoreNamedProcessCalls rewrites any calledElement matching {anything}-{digits} when that number is a process id. In-document or external call targets such as sid-1 become ${process:…} if process 1 exists, so GET process-bpmn can corrupt BPMN that was not produced by deploy resolution.
Reviewed by Cursor Bugbot for commit 4b27368. Configure here.
| ->env([ | ||
| 'PATH' => '/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:' . (getenv('PATH') ?: ''), | ||
| ]) | ||
| ->run(['composer', 'install', '--no-interaction']); |
There was a problem hiding this comment.
🔒 Agentic Security Review
Severity: MEDIUM
Description: Plugin install treats an untrusted composer.json as Composer project policy. finishPluginSetup only checks that some PSR-4 prefix starts with ProcessMaker\Plugins, ProcessMaker\Package, or ProcessMaker\Packages, then runs composer install --no-interaction with the working directory set to storage/plugins/. That invocation does not pass --no-scripts or --no-plugins and does not set COMPOSER_VENDOR_DIR. Composer runs the root package scripts (including pre-install-cmd) as the queue user, honors config.allow-plugins from that file, resolves dependencies from composer.json repositories, and installs into config.vendor-dir when set. A relative vendor-dir of ../../../vendor from storage/plugins/ is the application vendor directory. PluginServiceProvider only requires storage/plugins//vendor/autoload.php and skips the plugin when that file is absent, so a redirected install never has to load the plugin to change packages the application autoloader serves. revertFailedInstall and uninstall delete only the plugin directory, so those writes remain after a failed install or a later uninstall.
Impact: A manage-plugins operator (the permission is not on the seeded Requester, Process Designer, or Administrator groups) can submit any https git URL or zip. The author of that artifact then gets command execution as the queue worker during composer install, including when install later fails and the plugin directory is rolled back, and can replace application vendor files that stay on the shared autoloader after uninstall. That is broader than the intended plugin runtime: service providers are loaded only from the plugin's own vendor/autoload.php and only while the plugin directory remains. The worker can read the application environment and write storage; scripts run as that same user, so the reachable impact is credential disclosure and full control of the application process.
Remediation: Before composer install, reject composer.json scripts, allow-plugins, repositories, and config keys that move the install root or disable secure-http (especially config.vendor-dir). Run composer with --no-scripts --no-plugins and set COMPOSER_VENDOR_DIR to the absolute path of that plugin's vendor directory. Keep treating a loaded plugin's own service providers as a separate, explicit trust decision.
Persist named preview data presets for screens and versions, expose them through the screen API and MCP tools, and add Screen Builder controls to create, edit, reorder, apply, and update presets.
Proof of concept for running a PHP script without Docker
Task/FOUR-34405: Persist screen input data for preview and create data scenarios list
| } | ||
| } | ||
|
|
||
| private function shouldRunInProcess(): bool |
There was a problem hiding this comment.
🔒 Agentic Security Review
Severity: HIGH
Description: A user with only create-scripts or edit-scripts can persist allow_in_process=true and execution_mode=bare. When CORE_SERVICE_TASK_ENABLED is on, the next PHP script run through Script::runScript (process script tasks and RunScriptTask) takes ScriptRunner::shouldRunInProcess and executes the script with InProcessPhpRunner as the application user. authorizeModulesExecution and canUseModules gate only execution_mode=modules; they return immediately for bare mode. The UI checkbox is shown to every PHP script editor. InProcessPhpRunner::buildEnvironment copies the worker $_ENV and $_SERVER into the child, so the script can return worker secrets that the Docker runner never passes.
Impact: Script editors are not administrators. Docker and the script microservice previously isolated their PHP from the worker. This change lets that same editor opt the script onto the host and read the worker environment (standard Laravel boot places APP_KEY and DB_* in $_ENV/$_SERVER) and the application filesystem as the worker UID. The new run-in-process-modules permission shows modules-in-worker execution was meant to be privileged; the bare host path skips that gate. Reachable only after CORE_SERVICE_TASK_ENABLED=true (default false), but enabling the feature is the supported configuration and the editor can then script the API end to end.
Remediation: Require is_administrator or a dedicated permission before allow_in_process can be stored or before ScriptRunner::shouldRunInProcess and the preview in-process path honor it. Do not treat bare mode as the safe fallback for callers who fail the modules check. Pass the PHP subprocess only the same environment allowlist the Docker runner uses, not $_ENV/$_SERVER.
| Route::post('scripts/microservice/execution', [ScriptController::class, 'microserviceExecution']); | ||
|
|
||
| // Deploy / sync helpers (core). Canonical paths + package-skeleton aliases for BC. | ||
| Route::post('deploy-script', [DeployScript::class, 'deployScript'])->name('deploy-script'); |
There was a problem hiding this comment.
🔒 Agentic Security Review
Severity: HIGH
Description: The new deploy and get-by-name routes for scripts, screens, and processes are registered inside the auth:api group with no can: middleware and no controller authorize() call. Any logged-in user, including a Requesters-group account that cannot create, edit, or view these assets, can read published script PHP, screen YAML, and process BPMN by title or name and can create or overwrite those records. DeployScript sets run_as_user_id only when inserting a new row, so an update keeps the existing run-as user, publishes the attacker PHP as the latest script version, and the next script task runs that code with a freshly minted API token for that user. DeployProcess likewise replaces BPMN by name and marks a newly created process ACTIVE. A script task in that BPMN with no pm:scriptRef runs inline code as the first administrator.
Impact: This crosses the designer permission boundary that already gates the sibling script, screen, and process APIs. A normal requester session (Passport laravel_token from web login, or any other auth:api token) can replace a production script or process definition. Script execution then uses the preserved run_as_user_id and GenerateAccessToken, so the attacker PHP receives that user's API credential. Inline BPMN script bodies with an empty scriptRef use Script::defaultRunAsUser(), the first administrator. Screen YAML updates publish config, computed, watchers, and custom CSS for later renders.
Remediation: Put the same CustomAuthorize abilities used by the existing resource routes on both the canonical and package-skeleton aliases: can:create-scripts on create, can:edit-scripts on the resolved script for update, can:view-scripts for getScriptPhp, and the matching create/edit/view abilities for screens and processes. After the title or name lookup, call authorize() on that model so project-scoped edit checks still apply. Do not upsert or return source by title or name alone. On script update, do not keep a foreign run_as_user_id unless the caller is allowed to edit that script.
| } | ||
|
|
||
| TestScript::dispatch($script, $request->user(), $code, $data, $config, $nonce)->onQueue('bpmn'); | ||
| if ($request->boolean('run_in_process')) { |
There was a problem hiding this comment.
🔒 Agentic Security Review
Severity: HIGH
Description: With Core Service Task enabled, POST /api/1.0/scripts/{script}/preview runs the request body's PHP on the host when run_in_process is true, without the allow_in_process gate that task execution enforces. The route only requires view-scripts, which is separate from edit-scripts, so a caller who cannot save allow_in_process or change the script can still queue that host run. TestScript passes the unsaved request code to InProcessPhpRunner. The subprocess is the configured PHP binary, started from the queue worker with array_merge($_ENV, $_SERVER), every decrypted EnvironmentVariable, and a Passport API token for the script's run-as user. The script return value is broadcast back to the caller on ScriptResponseEvent. ScriptExecutionModeResolver forces bare mode when allow_in_process is false, so this path does not enter ScriptRuntime modules, but the bare host process is enough.
Impact: Enabling CORE_SERVICE_TASK_ENABLED is documented as an opt-in host runner limited to scripts with allow_in_process=true. Preview treats a client boolean as that decision and executes unsaved code as the bpmn queue worker. A view-scripts user (not granted to the default Requesters group, and not the same permission as edit-scripts) can read worker secrets and environment-variable values that the environment-variables API withholds, act as the script run-as user for the duration of the process, and return the results on their private broadcast channel. Task runs and CoreServiceTask still refuse the same host path unless allow_in_process is set. The preview-before-save flag is covered by testPreviewScriptInProcessWithRequestFlag, but that does not authorize view-only callers or this environment.
Remediation: Use the same allow_in_process requirement as ScriptRunner::shouldRunInProcess for preview. Do not let the request flag alone select host execution. If unsaved in-process preview must remain, require edit-scripts or a dedicated in-process permission, and only for callers who could already persist the gate. Pass the subprocess a scrubbed environment containing the intended script variables and a short-lived run-as token, not the worker $_ENV/$_SERVER or every environment-variable secret.
| */ | ||
| private function buildEnvironment(?User $user, ?GenerateAccessToken $accessToken): array | ||
| { | ||
| $env = array_merge($_ENV, $_SERVER); |
There was a problem hiding this comment.
🔒 Agentic Security Review
Severity: HIGH
Description: Bare in-process PHP execution copies the queue worker's full process environment into the script subprocess. A Process Designer (view-scripts / edit-scripts) can return getenv('APP_KEY'), getenv('DB_PASSWORD'), and the other worker secrets through the normal script output. Docker and ScriptMicroserviceRunner only pass EnvironmentVariable rows, HOST_URL, and an API token.
Impact: Process Designers are allowed to author PHP, but they are not the worker secret store. With CORE_SERVICE_TASK_ENABLED, preview or an allow_in_process script runs on the bare runner and the script return value is delivered back to that user. That exposes application credentials the microservice and Docker runners deliberately omit, including APP_KEY and database passwords from the worker environment. Those credentials decrypt application data and open the database. The bare checkbox is not gated by run-in-process-modules; the default Process Designers group has view-scripts, create-scripts, and edit-scripts only.
Remediation: Build the bare subprocess environment the same way ScriptMicroserviceRunner::getEnvironmentVariables does: EnvironmentVariable rows, HOST_URL/APP_URL, smart-extract settings, and the per-run API token. Do not array_merge $_ENV or $_SERVER. If a few host binaries are required, pass an explicit allowlist such as PATH. Because this process still runs as the worker user, also confine it (separate user, open_basedir, or a root that cannot read .env and bootstrap/cache/config.php); otherwise the same script can read those files even after the environment is curated.
| { | ||
| $instances = $this->instantiateModules($context); | ||
| $scriptPath = $this->writeTempScript($code); | ||
| $hasExplicitReturn = $this->hasExplicitReturn($code); |
There was a problem hiding this comment.
Return detection skips PHP normalization
High Severity
hasExplicitReturn tokenizes the original script body, while writeTempScript first prepends <?php when it is missing. ProcessMaker scripts usually omit that tag, so token_get_all treats the body as inline HTML and never sees T_RETURN. An explicit return 1 or return null then looks like a successful include, and the runtime substitutes the default $result error array instead of the returned value, which can overwrite process data in modules execution.
Additional Locations (1)
Reviewed by Cursor Bugbot for commit 8cd1706. Configure here.
| }, | ||
| onPreviewPresetsReorder() { | ||
| this.persistPreviewPresets(); | ||
| }, |
There was a problem hiding this comment.
Reorder leaves stale preset selection
Medium Severity
Dragging preview presets persists the new order but does not remap activePreviewPresetIndex. The radio stays on the old numeric index, so a different preset appears selected while Monaco still shows the previous payload, and the dirty Update/Discard controls compare against the wrong preset.
Additional Locations (1)
Reviewed by Cursor Bugbot for commit 8cd1706. Configure here.
| isPhpScript(isPhp) { | ||
| if (!isPhp) { | ||
| this.formData.allow_in_process = false; | ||
| this.formData.execution_mode = 'bare'; |
There was a problem hiding this comment.
Modules mode survives in-process disable
Low Severity
execution_mode is reset to bare only when the language is not PHP. Unchecking Allow Run Script without Docker leaves execution_mode at modules, and save still posts that value, so the model rejects the request because modules require allow_in_process.
Additional Locations (1)
Reviewed by Cursor Bugbot for commit 8cd1706. Configure here.
There was a problem hiding this comment.
Cursor Bugbot has reviewed your changes using high effort and found 2 potential issues.
There are 19 total unresolved issues (including 17 from previous reviews).
❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.
Reviewed by Cursor Bugbot for commit 0b976d2. Configure here.
| } | ||
|
|
||
| $request->merge(['execution_mode' => Script::EXECUTION_MODE_BARE]); | ||
| } |
There was a problem hiding this comment.
Script update strips modules mode
Medium Severity
authorizeModulesExecution treats a missing execution_mode as the script’s current value. On update, a user with edit-scripts but without run-in-process-modules therefore merges execution_mode to bare and fill() persists it, even when they only changed title or code. Modules mode is silently cleared instead of being left alone or rejected.
Additional Locations (1)
Reviewed by Cursor Bugbot for commit 0b976d2. Configure here.
| $submenu->add(__('Plugins'), [ | ||
| 'route' => 'plugins.index', | ||
| 'icon' => 'fa-plug', | ||
| ]); |
There was a problem hiding this comment.
Plugins menu ignores manage-plugins
Medium Severity
The Plugins item is added only inside the is_administrator block, while the page and API require manage-plugins. Admin home also redirects view-plugins to plugins.index. Non-admin users with manage-plugins never see the menu; users with only view-plugins are sent to a route that 403s.
Additional Locations (1)
Reviewed by Cursor Bugbot for commit 0b976d2. Configure here.


MCP Server
Related Tickets & Packages
PR's Related
ProcessMaker/modeler#1970
ProcessMaker/nayra#241
ci:deploy
ci:nayra:FOUR-34376
ci:modeler:feature/FOUR-34380